/**
 *\file joueur.c
 *\author Raphaël Diana
 */
#include "joueur.h"
#include <assert.h>
#include <stddef.h>
#include <stdio.h>

/* ---------------------------------------------- GESTION STRUCTURE & MEMOIRE ----------------------------------------------*/

CaseJeu creerCaseJeu()
{
    CaseJeu caseJeu;
    caseJeu.indice=0;
    caseJeu.hand=initListe();
    caseJeu.mise=0;
    caseJeu.assurance=0;
    caseJeu.doublee=0;
    caseJeu.paiement=0;
    return caseJeu;
}

CaseJeu* creerJeuJoueur()
{
    CaseJeu* jeu;
    unsigned int i;
    jeu=(CaseJeu*)malloc(12*sizeof(CaseJeu));/*on ne peut jouer que sur trois tableau
    different pour une case mais on reserve 4 places(pour conserver l'ordre des cartes) 4 places *3 cases = 12*/
    for(i=0; i<12; i++)
    {
        jeu[i]=creerCaseJeu();
    }
    return jeu;
}

Joueur* creerJoueur()
{

    Joueur* joueur;
    joueur=(Joueur*)malloc(sizeof(Joueur));
    joueur->credit=0;
    joueur->jeu=NULL;
    joueur->nombreDeMain=0;

    return joueur;
}
void initJeuJoueur(Joueur* joueur)
{
    int i, j;
    assert(joueur->jeu==NULL);
    joueur->jeu=creerJeuJoueur();
    for(i=0; i<3; i++)
    {
        for(j=0; j<4; j++)
        {
            joueur->jeu[4*i+j].indice=i+1;/*on met les indices des cases (case 1, 2 et 3)*/
        }
    }
}

void videCaseJeu(CaseJeu* hand)
{
    if(hand->hand!=NULL)
    {
        testamentListe(&hand->hand);
    }
    hand->mise=0;
    hand->assurance=0;
    hand->doublee=0;
    hand->paiement=0;
}

void videJeuJoueur(Joueur* joueur)
{
    int i;
    CaseJeu* jeu;
    jeu=joueur->jeu;
    if(jeu!=NULL)
    {
        for(i=0; i<12; i++)
        {
            videCaseJeu(&jeu[i]);
            joueur->nombreDeMain--;
        }
    }
}

void testamentJeuJoueur(Joueur* j)
{
    if(j->jeu!=NULL)
    {
        videJeuJoueur(j);
        free(j->jeu);
        j->jeu=NULL;
    }
}

void videJoueur(Joueur* joueur)
{
    if(joueur!=NULL)
    {
        testamentJeuJoueur(joueur);
        joueur->credit=0;
        joueur->nombreDeMain=0;
    }
}

void testamentJoueur(Joueur ** joueur)
{
    videJoueur(*joueur);
    free(*joueur);
    *joueur=NULL;
}

/* ---------------------------------------------- FIN GESTION STRUCTURE & MEMOIRE ----------------------------------------------*/

/* ---------------------------------------------- ACCESSEUR ----------------------------------------------*/
int testdoubleJoueur(const CaseJeu * c)
{
    assert(c!=NULL);
    return c->doublee;
}

int testMiseJoueur(const Joueur* joueur, int indice)
{
    return joueur->jeu[indice].mise;
}

int testCreditJoueur(const Joueur * j)
{
    assert(j!=NULL);
    return j->credit;
}

int testMiseCase(const Joueur* joueur, int indice)
{
    return joueur->jeu[indice].mise;
}

Liste* getListeJoueur(const Joueur* joueur, int indice)
{
    return joueur->jeu[indice].hand;
}

unsigned int getNombreCarte(Joueur* joueur, int indice)
{
    return getNombreElement(joueur->jeu[indice].hand);
}

unsigned int getIndiceCase(Joueur* joueur, int indice)
{
    return joueur->jeu[indice].indice;
}

int testBlackjackCase(const Joueur* joueur, int indice)
{
    return testBlackjack(joueur->jeu[indice].hand)&& joueur->jeu[indice].indice<4;
}


/* ---------------------------------------------- FIN ACCESSEUR ----------------------------------------------*/

/* ---------------------------------------------- MUTATEUR ----------------------------------------------*/
void doubleJoueur(CaseJeu *c)
{
    assert(c->doublee!=1);
    c->doublee=1;
}
void crediteJoueur(Joueur* joueur, unsigned int somme)
{
    assert(joueur!=NULL);
    joueur->credit=somme;
}

void separerListeJoueur(Joueur* joueur, int indice)
{
    int i;
    assert(indice>=0 && indice<12);
    assert(indice<=17);
    if(joueur->jeu[indice].indice<4)
    {
        i=2;
    }
    else
    {
        i=1;
    }
    testamentListe(&(joueur->jeu[indice+i].hand));
    joueur->jeu[indice+i].hand=separeListe(joueur->jeu[indice].hand);/*on insere la main resultant de la separation a la suite*/
    joueur->jeu[indice+i].indice=10*joueur->jeu[indice].indice+2;
    joueur->jeu[indice].indice=10*joueur->jeu[indice].indice+1;
    joueur->jeu[indice+i].mise=joueur->jeu[indice].mise;
    joueur->credit-=joueur->jeu[indice+i].mise;
    joueur->nombreDeMain ++;
}

void paiementJoueur(Joueur* joueur, unsigned int gain)
{
    joueur->credit=joueur->credit+gain;
}



void placeMise(Joueur*joueur, unsigned int mise, int nb)
{
    assert(joueur!=NULL);
    joueur->jeu[nb].mise=mise;
    joueur->credit=joueur->credit-mise;
}

void doubleMise(Joueur* joueur, unsigned int nb)
{
    assert(joueur!=NULL);
    assert(joueur->jeu[nb].mise!=0);
    assert(testNombreCarte(joueur->jeu[nb].hand)==2);
    joueur->jeu[nb].mise=2*joueur->jeu[nb].mise;
    joueur->credit=joueur->credit-1/2*joueur->jeu[nb].mise;
    joueur->jeu[nb].doublee=1;
}


void prendreAssurance(Joueur* joueur, CaseJeu* caseJeu, unsigned int nb)
{
    assert(joueur!=NULL);
    if(nb)
    {
        caseJeu->assurance=((float)(caseJeu->mise))/2;
        joueur->credit=joueur->credit-(caseJeu->assurance);
    }
}

void resetJeuJoueur(Joueur* joueur)
{
    testamentJeuJoueur(joueur);
    initJeuJoueur(joueur);
}
/* ---------------------------------------------- FIN MUTATEUR ----------------------------------------------*/

/* ---------------------------------------------- AFFICHAGE ----------------------------------------------*/
void afficheMainJoueur(const Joueur * j,unsigned int ind)
{

    printf("\n ----- Main %u du Joueur ----- \n", j->jeu[ind].indice);

    afficheMain(j->jeu[ind].hand);
}
/* ---------------------------------------------- FIN AFFICHAGE ----------------------------------------------*/



